/* The file is saved in UTF-8 codepage.
 * Check: «Stereotype», Section mark-§, Copyright-©, Alpha-α, Beta-β, Smile-☺
 */
package cz.pecinovsky.english.lootp._134_;


//import cz.pecinovsky.english.lootp._000_.Run;

//import cz.pecinovsky.english.lootp.utility.IO;


//import cz.pecinovsky.english.lootp._134_.ZrnitostHodinCykly_143_.ZrnitostHodinCykly;
////////////////////////////////////////////////////////////////////////////////
//%%+  +++++ End of ignored starting test - place for imports +++++
//%X+ xxxxx Start of the ovejumped text with declaration of the envelope xxxxx
/*******************************************************************************
 *<pre>
 * Předchozí:   Není - toto_je_nově_definovaná_třída
 *              Ttt v projektu Ppp
 * Následující: Prozatím není
 *
 * Projekt  Ppp
 *   + Přidáno
 *   - Odebráno
 *   ~ Změněno
 *</pre>
 */
public class ZrnitostHodinCykly_143_
{    private ZrnitostHodinCykly_143_() {}   static
////////////////////////////////////////////////////////////////////////////////
//%X- ----- End of the ovejumped text with declaration of the envelope -----


/*******************************************************************************
 * Třída {@code ZrnitostHodinCykly} obsahuje několik statickým metod,
 * které testují zrnitost údajů systémových hodin a speed porcesoru.
 * Metody vypisují počet milisekund uplynuvších mezi dvěma tiky hodin
 * a současně také počet běhů cyklem mezi těmito tiky.
 * Většina metod provádí tento test opakovaně a tak názorně demonstruje
 * nerovnoměrnou speed zpracování programů.
 *
 * @author Rudolf PECINOVSKÝ
 * @version 6.03.2017 — 2010-11-08
 */
public class ZrnitostHodinCykly
{
//== CONSTANT CLASS ATTRIBUTES =================================================
//== VARIABLE CLASS ATTRIBUTES =================================================
//== STATIC CONSTRUCTOR (CLASS INITIALIZER, STATIC INICITALIZING BLOCK) ======== 
//== CONSTANT INSTANCE ATTRIBUTES ==============================================
//== VARIABLE INSTANCE ATTRIBUTES ==============================================
//== CLASS GETTERS AND SETTERS =================================================
//== OTHER NON-PRIVATE CLASS METHODS ===========================================

    /***************************************************************************
     * Jednorázový test využívající cyklus do.
     */
    public static void jednorázový_do()
    {
        long první = System.currentTimeMillis();
        int  dotaz = 0;
        long druhý;

        do{
            dotaz++;
            druhý = System.currentTimeMillis();
        }while (první == druhý);
        System.out.println("Tik " + (druhý-první) +
                           " ms po " + dotaz + ". čtení");
    }


    /***************************************************************************
     * Zadaný počet krát změří dobu mezi dvěma tiky hodin a počet průchodů
     * cyklem, které za tu dobu program stihnul.
     *
     * @param pokusů Kolikrát budeme probíhat cyklem
     */
    public static void testZrnitostiHodin_while(int pokusů)
    {
        int  pokus = 0;
        long první = System.currentTimeMillis();
        long druhý = první;
        System.out.println("===== ZAČÁTEK TESTU ZRNITOSTI =====");
        while (++pokus <= pokusů)
        {
            int  dotazů = 0;
            while (druhý == první) {
                dotazů++;
                druhý = System.currentTimeMillis();
            }
            System.out.println("Pokus "  + pokus  + ":  Tik=" + (druhý-první) +
                               " ms po " + dotazů + ". čtení");
            první = druhý;
        }
        System.out.println("===== KONEC TESTU ZRNITOSTI =====");
    }


    /***************************************************************************
     * Opakování jednorázového testu v cyklu while.
     *
     * @param pokusů Kolikrát budeme probíhat cyklem
     */
    public static void testHodin_while(int pokusů)
    {
        int pokus = 1;

        System.out.println("===== ZAČÁTEK TESTU WHILE =====");
        while (pokus <= pokusů)
        {
            System.out.print("Pokus " + pokus + ": ");
            jednorázový_do();
            pokus++;
        }
        System.out.println("===== KONEC TESTU WHILE =====");
    }


    /***************************************************************************
     * Opakování jednorázového testu v cyklu for.
     *
     * @param pokusů Kolikrát budeme probíhat cyklem
     */
    public static void testHodin_for (int pokusů)
    {
        System.out.println("===== ZAČÁTEK TESTU FOR =====");
        for (int pokus = 1;   pokus <= pokusů;   pokus++)
        {
            System.out.print("Pokus " + pokus + ": ");
            jednorázový_do();
        }
//      System.out.println("Provedli jsme " + pokus + " pokusů");
        System.out.println("===== KONEC TESTU FOR =====");
    }


    /***************************************************************************
     * Opakování jednorázového testu v nekonečném cyklu for (;;).
     */
    public static void nekonečný()
    {
        System.out.println("===== ZAČÁTEK NEKONEČNÉHO TESTU =====");
        for (;;)
        {
            jednorázový_do();
        }
    //      System.out.println("===== KONEC NEKONEČNÉHO TESTU =====");
    }


    /***************************************************************************
     * Sloučení obou předchozích testů do jediné metody.
     *
     * @param pokusů Kolikrát budeme probíhat cyklem
     */
    public static void testHodin_vnořený(int pokusů)
    {
        System.out.println("===== ZAČÁTEK TESTU S VNOŘENÝM CYKLEM =====");

        long minule = System.currentTimeMillis();

        for (int pokus = 1;   pokus <= pokusů;   pokus++)
        {
            int  dotaz = 0;
            long nyní;

            do{
                dotaz++;
                nyní = System.currentTimeMillis();
            }while (nyní == minule);
            System.out.println("Pokus " + pokus +
                               ": tik " + (nyní-minule) +
                               " ms po " + dotaz + ". čtení");
            minule = nyní;
        }
        System.out.println("===== KONEC TESTU S VNOŘENÝM CYKLEM =====");
    }


    /***************************************************************************
     * Sloučení obou předchozích testů do jediné metody.
     *
     * @param sekund Jak dlouho budeme probíhat cyklem
     */
    public static void testHodin_uprostřed(int sekund)
    {
        System.out.println("===== ZAČÁTEK TESTU S PEVNOU DOBOU MĚŘENÍ =====");

        long start  = System.currentTimeMillis();
        long minule = start;

        for (;;)
        {
            long nyní;
            int  dotaz = 0;

            do{
                nyní = System.currentTimeMillis();
                dotaz++;
            }while (nyní == minule);
            long měří_s = (int)((nyní - start)/1000);

            if (měří_s  >=  sekund) {  //Podmínka testující setrvání v cyklu
                break;                  //Příkaz k ukončení cyklu
            }
            int měří_ms = (int)((nyní - start)%1000);
            System.out.println("Čas " + měří_s + "s, " + měří_ms +
                               "ms, tik " + (nyní-minule) +
                               " ms po " + dotaz + ". čtení");
            minule = nyní;
        }
        System.out.println("===== KONEC TESTU S PEVNOU DOBOU MĚŘENÍ =====");
    }


    /***************************************************************************
     * Metoda ukazuje, že v některých případech může mít cyklus prázdné tělo.
     *
     * @param sekund Jak dlouho budeme probíhat cyklem
     */
    @SuppressWarnings("empty-statement")
    public static void testHodin_bezTěla(int sekund)
    {
        System.out.println("===== ZAČÁTEK TESTU S PRÁZDNÝM TĚLEM =====");
        long start  = System.currentTimeMillis();
        long minule = start;

        for (;;)
        {
            while (minule == System.currentTimeMillis());
            long nyní = System.currentTimeMillis();
            long měří_s = (int)((nyní - start)/1000);

            if (měří_s  >=  sekund) {  //Podmínka testující setrvání v cyklu
                break;                  //Příkaz k ukončení cyklu
            }
            int měří_ms = (int)((nyní - start)%1000);
            System.out.println("Čas " + měří_s + "s, " + měří_ms +
                               "ms, tik " + (nyní-minule));
            minule = nyní;
        }
        System.out.println("===== KONEC TESTU S PRÁZDNÝM TĚLEM =====");
    }



//##############################################################################
//== CONSTUCTORS AND FACTORY METHODS ===========================================

    /** Soukromy konstruktor bránící vytvoření instance. */
    private ZrnitostHodinCykly() {}


//== ABSTRACT METHODS ==========================================================
//== INSTANCE GETTERS AND SETTERS ==============================================
//== OTHER NON-PRIVATE INSTANCE METHODS ========================================
//== PRIVATE AND AUXILIARY CLASS METHODS =======================================
//== PRIVATE AND AUXILIARY INSTANCE METHODS ====================================
//== EMBEDDED TYPES AND INNER CLASSES ==========================================
//== TESTING CLASSES AND METHODS ===============================================

    /***************************************************************************
     * Test method.
     */
    public static void test()
    {
        ZrnitostHodinCykly.testZrnitostiHodin_while(100);
    }
//    /** @param args Parametry příkazového řádku - nepoužívané. */
//    public static void main(String[] args)  {  test();  }
}

//%%- ---- Start of the ovejumped text with closing of the envelope ----
////////////////////////////////////////////////////////////////////////////////
//== TESTING CLASSES AND METHODS ===============================================

    /***************************************************************************
     * Test method.
     */
    public static void test()
    {
        ZrnitostHodinCykly.test();
//        IO.zpráva("Až se pokocháš, stiskni OK");
//        System.exit(0);
    }
    /** @param args Parametry příkazového řádku - nepoužívané. */
    public static void main(String[] args)  {  test();  }
}
